{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install pyvirtualdisplay\n",
    "    !pip install gym[all]\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 06. Categorical DQN\n",
    "\n",
    "[M. G. Bellemare et al., \"A Distributional Perspective on Reinforcement Learning.\" arXiv preprint arXiv:1707.06887, 2017.](https://arxiv.org/pdf/1707.06887.pdf)\n",
    "\n",
    "The authors argued the importance of learning the distribution of returns instead of the expected return, and they proposed to model such distributions with probability masses placed on a discrete support $z$, where $z$ is a vector with $N_{atoms} \\in \\mathbb{N}^+$ atoms, defined by $z_i = V_{min} + (i-1) \\frac{V_{max} - V_{min}}{N-1}$ for $i \\in \\{1, ..., N_{atoms}\\}$.\n",
    "\n",
    "The key insight is that return distributions satisfy a variant of Bellman’s equation. For a given state $S_t$ and action $A_t$, the distribution of the returns under the optimal policy $\\pi^{*}$ should match a target distribution defined by taking the distribution for the next state $S_{t+1}$ and action $a^{*}_{t+1} = \\pi^{*}(S_{t+1})$, contracting\n",
    "it towards zero according to the discount, and shifting it by the reward (or distribution of rewards, in the stochastic case). A distributional variant of Q-learning is then derived by first constructing a new support for the target distribution, and then minimizing the Kullbeck-Leibler divergence between the distribution $d_t$ and the target distribution\n",
    "\n",
    "$$\n",
    "d_t' = (R_{t+1} + \\gamma_{t+1} z, p_\\hat{{\\theta}} (S_{t+1}, \\hat{a}^{*}_{t+1})),\\\\\n",
    "D_{KL} (\\phi_z d_t' \\| d_t).\n",
    "$$\n",
    "\n",
    "Here $\\phi_z$ is a L2-projection of the target distribution onto the fixed support $z$, and $\\hat{a}^*_{t+1} = \\arg\\max_{a} q_{\\hat{\\theta}} (S_{t+1}, a)$ is the greedy action with respect to the mean action values $q_{\\hat{\\theta}} (S_{t+1}, a) = z^{T}p_{\\theta}(S_{t+1}, a)$ in state $S_{t+1}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Please see *01.dqn.ipynb* for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self, \n",
    "        obs: np.ndarray, \n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "The parametrized distribution can be represented by a neural network, as in DQN, but with atom_size x out_dim outputs. A softmax is applied independently for each action dimension of the output to ensure that the distribution for each action is appropriately normalized.\n",
    "\n",
    "To estimate q-values, we use inner product of each action's softmax distribution and support which is the set of atoms $\\{z_i = V_{min} + i\\Delta z: 0 \\le i < N\\}, \\Delta z = \\frac{V_{max} - V_{min}}{N-1}$.\n",
    "\n",
    "$$\n",
    "Q(s_t, a_t) = \\sum_i z_i p_i(s_t, a_t), \\\\\n",
    "\\text{where } p_i \\text{ is the probability of } z_i \\text{ (the output of softmax)}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        out_dim: int, \n",
    "        atom_size: int, \n",
    "        support: torch.Tensor\n",
    "    ):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.support = support\n",
    "        self.out_dim = out_dim\n",
    "        self.atom_size = atom_size\n",
    "        \n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim * atom_size)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        dist = self.dist(x)\n",
    "        q = torch.sum(dist * self.support, dim=2)\n",
    "        \n",
    "        return q\n",
    "    \n",
    "    def dist(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Get distribution for atoms.\"\"\"\n",
    "        q_atoms = self.layers(x).view(-1, self.out_dim, self.atom_size)\n",
    "        dist = F.softmax(q_atoms, dim=-1)\n",
    "        dist = dist.clamp(min=1e-3)  # for avoiding nans\n",
    "        \n",
    "        return dist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Categorical DQN Agent\n",
    "\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "All differences from pure DQN are noted with comments *Categorical DQN*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including\n",
    "                           state, action, reward, next_state, done\n",
    "        v_min (float): min value of support\n",
    "        v_max (float): max value of support\n",
    "        atom_size (int): the unit number of support\n",
    "        support (torch.Tensor): support for categorical dqn\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "        # Categorical DQN parameters\n",
    "        v_min: float = 0.0,\n",
    "        v_max: float = 200.0,\n",
    "        atom_size: int = 51,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "            v_min (float): min value of support\n",
    "            v_max (float): max value of support\n",
    "            atom_size (int): the unit number of support\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "        print(self.device)\n",
    "        \n",
    "        # Categorical DQN parameters\n",
    "        self.v_min = v_min\n",
    "        self.v_max = v_max\n",
    "        self.atom_size = atom_size\n",
    "        self.support = torch.linspace(\n",
    "            self.v_min, self.v_max, self.atom_size\n",
    "        ).to(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(\n",
    "            obs_dim, action_dim, atom_size, self.support\n",
    "        ).to(self.device)\n",
    "        self.dqn_target = Network(\n",
    "            obs_dim, action_dim, atom_size, self.support\n",
    "        ).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device),\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state = self.env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self) -> List[np.ndarray]:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        return frames\n",
    "\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return categorical dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"]).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        \n",
    "        # Categorical DQN algorithm\n",
    "        delta_z = float(self.v_max - self.v_min) / (self.atom_size - 1)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            next_action = self.dqn_target(next_state).argmax(1)\n",
    "            next_dist = self.dqn_target.dist(next_state)\n",
    "            next_dist = next_dist[range(self.batch_size), next_action]\n",
    "\n",
    "            t_z = reward + (1 - done) * self.gamma * self.support\n",
    "            t_z = t_z.clamp(min=self.v_min, max=self.v_max)\n",
    "            b = (t_z - self.v_min) / delta_z\n",
    "            l = b.floor().long()\n",
    "            u = b.ceil().long()\n",
    "\n",
    "            offset = (\n",
    "                torch.linspace(\n",
    "                    0, (self.batch_size - 1) * self.atom_size, self.batch_size\n",
    "                ).long()\n",
    "                .unsqueeze(1)\n",
    "                .expand(self.batch_size, self.atom_size)\n",
    "                .to(self.device)\n",
    "            )\n",
    "\n",
    "            proj_dist = torch.zeros(next_dist.size(), device=self.device)\n",
    "            proj_dist.view(-1).index_add_(\n",
    "                0, (l + offset).view(-1), (next_dist * (u.float() - b)).view(-1)\n",
    "            )\n",
    "            proj_dist.view(-1).index_add_(\n",
    "                0, (u + offset).view(-1), (next_dist * (b - l.float())).view(-1)\n",
    "            )\n",
    "\n",
    "        dist = self.dqn.dist(state)\n",
    "        log_p = torch.log(dist[range(self.batch_size), action])\n",
    "\n",
    "        loss = -(proj_dist * log_p).sum(1).mean()\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/cartpole.py) and [configurations](https://github.com/openai/gym/blob/master/gym/envs/__init__.py#L53) of CartPole-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env_id = \"CartPole-v0\"\n",
    "env = gym.make(env_id)\n",
    "if IN_COLAB:\n",
    "    env = gym.wrappers.Monitor(env, \"videos\", force=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)\n",
    "env.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 20000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 200\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  200.0\n"
     ]
    }
   ],
   "source": [
    "frames = agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    document.getElementById(this.slider_id).max = this.frames.length - 1;\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<div class=\"animation\" align=\"center\">\n",
       "    <img id=\"_anim_imgKAOQEWWPJIKCZVVJ\">\n",
       "    <br>\n",
       "    <input id=\"_anim_sliderKAOQEWWPJIKCZVVJ\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animKAOQEWWPJIKCZVVJ.set_frame(parseInt(this.value));\"></input>\n",
       "    <br>\n",
       "    <button onclick=\"animKAOQEWWPJIKCZVVJ.slower()\">&#8211;</button>\n",
       "    <button onclick=\"animKAOQEWWPJIKCZVVJ.first_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animKAOQEWWPJIKCZVVJ.previous_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animKAOQEWWPJIKCZVVJ.reverse_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animKAOQEWWPJIKCZVVJ.pause_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animKAOQEWWPJIKCZVVJ.play_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animKAOQEWWPJIKCZVVJ.next_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animKAOQEWWPJIKCZVVJ.last_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animKAOQEWWPJIKCZVVJ.faster()\">+</button>\n",
       "  <form action=\"#n\" name=\"_anim_loop_selectKAOQEWWPJIKCZVVJ\" class=\"anim_control\">\n",
       "    <input type=\"radio\" name=\"state\" value=\"once\" > Once </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"loop\" checked> Loop </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n",
       "  </form>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgKAOQEWWPJIKCZVVJ\";\n",
       "    var slider_id = \"_anim_sliderKAOQEWWPJIKCZVVJ\";\n",
       "    var loop_select_id = \"_anim_loop_selectKAOQEWWPJIKCZVVJ\";\n",
       "    var frames = new Array(0);\n",
       "    \n",
       "  frames[0] = \"\"\n",
       "  frames[1] = \"\"\n",
       "  frames[2] = \"\"\n",
       "  frames[3] = \"\"\n",
       "  frames[4] = \"\"\n",
       "  frames[5] = \"\"\n",
       "  frames[6] = \"\"\n",
       "  frames[7] = \"\"\n",
       "  frames[8] = \"\"\n",
       "  frames[9] = \"\"\n",
       "  frames[10] = \"\"\n",
       "  frames[11] = \"\"\n",
       "  frames[12] = \"\"\n",
       "  frames[13] = \"\"\n",
       "  frames[14] = \"\"\n",
       "  frames[15] = \"\"\n",
       "  frames[16] = \"\"\n",
       "  frames[17] = \"\"\n",
       "  frames[18] = \"\"\n",
       "  frames[19] = \"\"\n",
       "  frames[20] = \"\"\n",
       "  frames[21] = \"\"\n",
       "  frames[22] = \"\"\n",
       "  frames[23] = \"\"\n",
       "  frames[24] = \"\"\n",
       "  frames[25] = \"\"\n",
       "  frames[26] = \"\"\n",
       "  frames[27] = \"\"\n",
       "  frames[28] = \"\"\n",
       "  frames[29] = \"\"\n",
       "  frames[30] = \"\"\n",
       "  frames[31] = \"\"\n",
       "  frames[32] = \"\"\n",
       "  frames[33] = \"\"\n",
       "  frames[34] = \"\"\n",
       "  frames[35] = \"\"\n",
       "  frames[36] = \"\"\n",
       "  frames[37] = \"\"\n",
       "  frames[38] = \"\"\n",
       "  frames[39] = \"\"\n",
       "  frames[40] = \"\"\n",
       "  frames[41] = \"\"\n",
       "  frames[42] = \"\"\n",
       "  frames[43] = \"\"\n",
       "  frames[44] = \"\"\n",
       "  frames[45] = \"\"\n",
       "  frames[46] = \"\"\n",
       "  frames[47] = \"\"\n",
       "  frames[48] = \"\"\n",
       "  frames[49] = \"\"\n",
       "  frames[50] = \"\"\n",
       "  frames[51] = \"\"\n",
       "  frames[52] = \"\"\n",
       "  frames[53] = \"\"\n",
       "  frames[54] = \"\"\n",
       "  frames[55] = \"\"\n",
       "  frames[56] = \"\"\n",
       "  frames[57] = \"\"\n",
       "  frames[58] = \"\"\n",
       "  frames[59] = \"\"\n",
       "  frames[60] = \"\"\n",
       "  frames[61] = \"\"\n",
       "  frames[62] = \"\"\n",
       "  frames[63] = \"\"\n",
       "  frames[64] = \"\"\n",
       "  frames[65] = \"\"\n",
       "  frames[66] = \"\"\n",
       "  frames[67] = \"\"\n",
       "  frames[68] = \"\"\n",
       "  frames[69] = \"\"\n",
       "  frames[70] = \"\"\n",
       "  frames[71] = \"\"\n",
       "  frames[72] = \"\"\n",
       "  frames[73] = \"\"\n",
       "  frames[74] = \"\"\n",
       "  frames[75] = \"\"\n",
       "  frames[76] = \"\"\n",
       "  frames[77] = \"\"\n",
       "  frames[78] = \"\"\n",
       "  frames[79] = \"\"\n",
       "  frames[80] = \"\"\n",
       "  frames[81] = \"\"\n",
       "  frames[82] = \"\"\n",
       "  frames[83] = \"\"\n",
       "  frames[84] = \"\"\n",
       "  frames[85] = \"\"\n",
       "  frames[86] = \"\"\n",
       "  frames[87] = \"\"\n",
       "  frames[88] = \"\"\n",
       "  frames[89] = \"\"\n",
       "  frames[90] = \"\"\n",
       "  frames[91] = \"\"\n",
       "  frames[92] = \"\"\n",
       "  frames[93] = \"\"\n",
       "  frames[94] = \"\"\n",
       "  frames[95] = \"\"\n",
       "  frames[96] = \"\"\n",
       "  frames[97] = \"\"\n",
       "  frames[98] = \"\"\n",
       "  frames[99] = \"\"\n",
       "  frames[100] = \"\"\n",
       "  frames[101] = \"\"\n",
       "  frames[102] = \"\"\n",
       "  frames[103] = \"\"\n",
       "  frames[104] = \"\"\n",
       "  frames[105] = \"\"\n",
       "  frames[106] = \"\"\n",
       "  frames[107] = \"\"\n",
       "  frames[108] = \"\"\n",
       "  frames[109] = \"\"\n",
       "  frames[110] = \"\"\n",
       "  frames[111] = \"\"\n",
       "  frames[112] = \"\"\n",
       "  frames[113] = \"\"\n",
       "  frames[114] = \"\"\n",
       "  frames[115] = \"\"\n",
       "  frames[116] = \"\"\n",
       "  frames[117] = \"\"\n",
       "  frames[118] = \"\"\n",
       "  frames[119] = \"\"\n",
       "  frames[120] = \"\"\n",
       "  frames[121] = \"\"\n",
       "  frames[122] = \"\"\n",
       "  frames[123] = \"\"\n",
       "  frames[124] = \"\"\n",
       "  frames[125] = \"\"\n",
       "  frames[126] = \"\"\n",
       "  frames[127] = \"\"\n",
       "  frames[128] = \"\"\n",
       "  frames[129] = \"\"\n",
       "  frames[130] = \"\"\n",
       "  frames[131] = \"\"\n",
       "  frames[132] = \"\"\n",
       "  frames[133] = \"\"\n",
       "  frames[134] = \"\"\n",
       "  frames[135] = \"\"\n",
       "  frames[136] = \"\"\n",
       "  frames[137] = \"\"\n",
       "  frames[138] = \"\"\n",
       "  frames[139] = \"\"\n",
       "  frames[140] = \"\"\n",
       "  frames[141] = \"\"\n",
       "  frames[142] = \"\"\n",
       "  frames[143] = \"\"\n",
       "  frames[144] = \"\"\n",
       "  frames[145] = \"\"\n",
       "  frames[146] = \"\"\n",
       "  frames[147] = \"\"\n",
       "  frames[148] = \"\"\n",
       "  frames[149] = \"\"\n",
       "  frames[150] = \"\"\n",
       "  frames[151] = \"\"\n",
       "  frames[152] = \"\"\n",
       "  frames[153] = \"\"\n",
       "  frames[154] = \"\"\n",
       "  frames[155] = \"\"\n",
       "  frames[156] = \"\"\n",
       "  frames[157] = \"\"\n",
       "  frames[158] = \"\"\n",
       "  frames[159] = \"\"\n",
       "  frames[160] = \"\"\n",
       "  frames[161] = \"\"\n",
       "  frames[162] = \"\"\n",
       "  frames[163] = \"\"\n",
       "  frames[164] = \"\"\n",
       "  frames[165] = \"\"\n",
       "  frames[166] = \"\"\n",
       "  frames[167] = \"\"\n",
       "  frames[168] = \"\"\n",
       "  frames[169] = \"\"\n",
       "  frames[170] = \"\"\n",
       "  frames[171] = \"\"\n",
       "  frames[172] = \"\"\n",
       "  frames[173] = \"\"\n",
       "  frames[174] = \"\"\n",
       "  frames[175] = \"\"\n",
       "  frames[176] = \"\"\n",
       "  frames[177] = \"\"\n",
       "  frames[178] = \"\"\n",
       "  frames[179] = \"\"\n",
       "  frames[180] = \"\"\n",
       "  frames[181] = \"\"\n",
       "  frames[182] = \"\"\n",
       "  frames[183] = \"\"\n",
       "  frames[184] = \"\"\n",
       "  frames[185] = \"\"\n",
       "  frames[186] = \"\"\n",
       "  frames[187] = \"\"\n",
       "  frames[188] = \"\"\n",
       "  frames[189] = \"\"\n",
       "  frames[190] = \"\"\n",
       "  frames[191] = \"\"\n",
       "  frames[192] = \"\"\n",
       "  frames[193] = \"\"\n",
       "  frames[194] = \"\"\n",
       "  frames[195] = \"\"\n",
       "  frames[196] = \"\"\n",
       "  frames[197] = \"\"\n",
       "  frames[198] = \"\"\n",
       "  frames[199] = \"\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        animKAOQEWWPJIKCZVVJ = new Animation(frames, img_id, slider_id, 50, loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if IN_COLAB:  # for colab\n",
    "    import base64\n",
    "    import glob\n",
    "    import io\n",
    "    import os\n",
    "\n",
    "    from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "    def ipython_show_video(path: str) -> None:\n",
    "        \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "        if not os.path.isfile(path):\n",
    "            raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "        video = io.open(path, \"r+b\").read()\n",
    "        encoded = base64.b64encode(video)\n",
    "\n",
    "        display(HTML(\n",
    "            data=\"\"\"\n",
    "            <video alt=\"test\" controls>\n",
    "            <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "            </video>\n",
    "            \"\"\".format(encoded.decode(\"ascii\"))\n",
    "        ))\n",
    "\n",
    "    list_of_files = glob.glob(\"videos/*.mp4\")\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    print(latest_file)\n",
    "    ipython_show_video(latest_file)\n",
    "    \n",
    "else:  # for jupyter\n",
    "    from matplotlib import animation\n",
    "    from JSAnimation.IPython_display import display_animation\n",
    "    from IPython.display import display\n",
    "\n",
    "\n",
    "    def display_frames_as_gif(frames: List[np.ndarray]) -> None:\n",
    "        \"\"\"Displays a list of frames as a gif, with controls.\"\"\"\n",
    "        patch = plt.imshow(frames[0])\n",
    "        plt.axis('off')\n",
    "\n",
    "        def animate(i):\n",
    "            patch.set_data(frames[i])\n",
    "\n",
    "        anim = animation.FuncAnimation(\n",
    "            plt.gcf(), animate, frames = len(frames), interval=50\n",
    "        )\n",
    "        display(display_animation(anim, default_mode='loop'))\n",
    "\n",
    "\n",
    "    # display \n",
    "    display_frames_as_gif(frames)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
